home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / ghostscript / 8.64 / Resource / Init / gs_lev2.ps < prev    next >
Encoding:
Text File  |  2009-04-17  |  33.8 KB  |  1,004 lines
  1. %    Copyright (C) 1990, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_lev2.ps 8962 2008-08-11 14:16:18Z ken $
  17. % Initialization file for Level 2 functions.
  18. % When this is run, systemdict is still writable,
  19. % but (almost) everything defined here goes into level2dict.
  20.  
  21. level2dict begin
  22.  
  23. % ------ System and user parameters ------ %
  24.  
  25. % User parameters must obey save/restore, and must also be maintained
  26. % per-context.  We implement the former, and some of the latter, here
  27. % with PostScript code.  NOTE: our implementation assumes that user
  28. % parameters change only as a result of setuserparams -- that there are
  29. % no user parameters that are ever changed dynamically by the interpreter
  30. % (although the interpreter may adjust the value presented to setuserparams)
  31. %
  32. % There are two types of user parameters: those which are actually
  33. % maintained in the interpreter, and those which exist only at the
  34. % PostScript level.  We maintain the current state of both types in
  35. % a read-only local dictionary named userparams, defined in systemdict.
  36. % In a multi-context system, each context has its own copy of this
  37. % dictionary.  In addition, there is a constant dictionary named
  38. % psuserparams where each key is the name of a user parameter that exists
  39. % only in PostScript and the value is a procedure to check that the value
  40. % is legal: setuserparams uses this for checking the values.
  41. % setuserparams updates userparams explicitly, in addition to setting
  42. % any user parameters in the interpreter; thus we can use userparams
  43. % to reset those parameters after a restore or a context switch.
  44. % NOTE: the name userparams is known to the interpreter, and in fact
  45. % the interpreter creates the userparams dictionary.
  46.  
  47. % Check parameters that are managed at the PostScript level.
  48. /.checkparamtype {        % <newvalue> <type> .checkparamtype <bool>
  49.   exch type eq
  50. } .bind def
  51. /.checksetparams {        % <newdict> <opname> <checkdict>
  52.                 %   .checksetparams <newdict>
  53.   2 .argindex {
  54.         % Stack: newdict opname checkdict key newvalue
  55.     3 copy 3 1 roll .knownget {
  56.       exec not {
  57.     pop pop pop load /typecheck signalerror
  58.       } if
  59.       dup type /stringtype eq {
  60.     dup rcheck not {
  61.       pop pop pop load /invalidaccess signalerror
  62.     } if
  63.       } if
  64.     } {
  65.       pop
  66.     } ifelse pop pop
  67.   } forall pop pop
  68. } .bind def    % not odef, shouldn't reset stacks
  69.  
  70. % currentuser/systemparams creates and returns a dictionary in the
  71. % current VM.  The easiest way to make this work is to copy any composite
  72. % PostScript-level parameters to global VM.  Currently we have strings
  73. % as well as arrays. For arrays, we also need to copy any contents that
  74. % are in VM. Also copying string parameters insures the contents won't
  75. % be changed. Also be careful to preserve 'executable' state.
  76. /.copyparam {            % <value> .copyparam <value'>
  77.   dup type /arraytype eq {
  78.     .currentglobal true .setglobal exch 
  79.     dup wcheck exch dup xcheck exch        % original attributes
  80.     dup length array exch dup {    % stack: destination_array original_array original_array
  81.       dup type /arraytype eq {
  82.     dup 2 index ne {    % avoid recursion
  83.           .copyparam    % recurse to handle composite array elements
  84.         } {
  85.       % this array self referenced, do it again (yuk!)
  86.       pop 1 index        % get copy of destination array
  87.     } ifelse
  88.       } {
  89.         dup type /stringtype eq {
  90.       .copyparam
  91.         } if 
  92.       }
  93.       ifelse 3 1 roll        % keep arrays on top
  94.     } forall pop astore
  95.     exch { cvx } if        % set executable state
  96.     exch not { readonly } if    % set readonly attribute as original
  97.     exch .setglobal
  98.   } if
  99.   dup type /stringtype eq {
  100.     dup wcheck exch    % save attr for setting readonly
  101.     .currentglobal true .setglobal
  102.     1 index length string exch .setglobal
  103.     copy exch not { readonly } if
  104.   } if
  105. } .bind def
  106.  
  107. % Some user parameters are managed entirely at the PostScript level.
  108. % We take care of that here.
  109. systemdict begin
  110. /psuserparams 48 dict def
  111. /getuserparam {            % <name> getuserparam <value>
  112.   /userparams .systemvar 1 .argindex get exch pop
  113. } odef
  114. % Fill in userparams (created by the interpreter) with current values.
  115. mark .currentuserparams
  116. counttomark 2 idiv {
  117.   userparams 3 1 roll put
  118. } repeat pop
  119. /.definepsuserparam {        % <name> <value> .definepsuserparam -
  120.   psuserparams 3 copy pop
  121.   type cvlit /.checkparamtype cvx 2 packedarray cvx put
  122.   userparams 3 1 roll put
  123. } .bind def
  124. end
  125. /currentuserparams {        % - currentuserparams <dict>
  126.   /userparams .systemvar dup length dict .copydict
  127. } odef
  128. % We break out setuserparams into a separate procedure so that setvmxxx
  129. % can use it without affecting the command in case of an error.
  130. /.setuserparams2 {
  131.     % Check that we will be able to set the PostScript-level
  132.     % user parameters.
  133.   /setuserparams /psuserparams .systemvar .checksetparams
  134.     % Set the C-level user params.  If this succeeds, we know that
  135.     % the password check succeeded.
  136.   dup .setuserparams
  137.     % Now set the PostScript-level params.
  138.     % The interpreter may have adjusted the values of some of the
  139.     % parameters, so we have to read them back.
  140.   dup {
  141.     /userparams .systemvar 2 index known {
  142.       psuserparams 2 index known not {
  143.     pop dup .getuserparam
  144.       } if
  145.       .copyparam
  146.       % special protection for the security related parameters
  147.       [ /PermitFileReading /PermitFileWriting /PermitFileControl ]
  148.       { 2 index eq { % force all strings to readonly but make sure the
  149.              % array is in the correct VM space (local/global).
  150.     currentglobal exch dup gcheck setglobal
  151.     dup length array exch { readonly exch } forall astore
  152.     exch setglobal
  153.         } if
  154.       } forall
  155.       % protect top level of parameters that we copied
  156.       dup type dup /arraytype eq exch /stringtype eq or { readonly } if
  157.       /userparams .systemvar 3 1 roll .forceput  % userparams is read-only
  158.     } {
  159.       pop pop
  160.     } ifelse
  161.   } forall
  162.     % A context switch might have occurred during the above loop,
  163.     % causing the interpreter-level parameters to be reset.
  164.     % Set them again to the new values.  From here on, we are safe,
  165.     % since a context switch will consult userparams.
  166.   .setuserparams
  167. } .bind def
  168. /setuserparams {        % <dict> setuserparams -
  169.     .setuserparams2
  170. } .bind odef
  171. % Initialize user parameters managed here.
  172. /JobName () .definepsuserparam
  173.  
  174. % Restore must restore the user parameters.
  175. % (Since userparams is in local VM, save takes care of saving them.)
  176. /restore {        % <save> restore -
  177.   //restore /userparams .systemvar .setuserparams
  178. } .bind odef
  179.  
  180. % The pssystemparams dictionary holds some system parameters that
  181. % are managed entirely at the PostScript level.
  182. systemdict begin
  183. currentdict /pssystemparams known not {
  184.   /pssystemparams 40 dict readonly def
  185. } if
  186. /getsystemparam {        % <name> getsystemparam <value>
  187.   //pssystemparams 1 .argindex .knownget { exch pop } { .getsystemparam } ifelse
  188. } odef
  189. end
  190. /currentsystemparams {        % - currentsystemparams <dict>
  191.   mark .currentsystemparams //pssystemparams { } forall .dicttomark
  192. } odef
  193. /setsystemparams {        % <dict> setsystemparams -
  194.     % Check that we will be able to set the PostScript-level
  195.     % system parameters.
  196.    dup pop        % check # of args
  197.    /SAFETY .systemvar /safe get {
  198.      % SAFER mode disallows some changes
  199.      [ /GenericResourceDir /FontResourceDir /GenericResourcePathSep ] {
  200.        2 copy .knownget {
  201.      exch //pssystemparams exch .knownget {
  202.            ne { /setsystemparams /invalidaccess signalerror } if
  203.          } {
  204.            pop
  205.          } ifelse
  206.        } {
  207.          pop
  208.        } ifelse
  209.      } forall
  210.    } if
  211.    /setsystemparams //pssystemparams mark exch {
  212.      type cvlit /.checkparamtype cvx 2 packedarray cvx
  213.    } forall .dicttomark .checksetparams
  214.     % Set the C-level system params.  If this succeeds, we know that
  215.     % the password check succeeded.
  216.    dup .setsystemparams
  217.     % Now set the PostScript-level params.  We must copy local strings
  218.     % into global VM.
  219.    dup
  220.     { //pssystemparams 2 index known
  221.        {        % Stack: key newvalue
  222.      .copyparam
  223.      % protect top level parameters that we copied
  224.          dup type dup /arraytype eq exch /stringtype eq or { readonly } if
  225.      //pssystemparams 3 1 roll .forceput    % pssystemparams is read-only
  226.        }
  227.        { pop pop
  228.        }
  229.       ifelse
  230.     }
  231.    forall pop
  232. } .bind odef
  233.  
  234. % Initialize the passwords.
  235. % NOTE: the names StartJobPassword and SystemParamsPassword are known to
  236. % the interpreter, and must be bound to noaccess strings.
  237. % The length of these strings must be max_password (iutil2.h) + 1.
  238. /StartJobPassword 65 string noaccess def
  239. /SystemParamsPassword 65 string noaccess def
  240.  
  241. % Redefine cache parameter setting to interact properly with userparams.
  242. /setcachelimit {
  243.     { mark /MaxFontItem 2 .argindex .dicttomark setuserparams pop }
  244.   stopped
  245.     {  /setcachelimit .systemvar $error /errorname get signalerror
  246.     } if
  247. } .bind odef
  248. /setcacheparams {
  249.     % The MaxFontCache parameter is a system parameter, which we might
  250.     % not be able to set.  Fortunately, this doesn't matter, because
  251.     % system parameters don't have to be synchronized between this code
  252.     % and the VM.
  253.   counttomark 1 add copy setcacheparams
  254.   currentcacheparams    % mark size lower upper
  255.     3 -1 roll pop
  256.     /MinFontCompress 3 1 roll
  257.     /MaxFontItem exch
  258.   .dicttomark { setuserparams cleartomark } stopped {
  259.     /setcacheparams .systemvar $error /errorname get signalerror
  260.   } if
  261. } .bind odef
  262.  
  263. % Add bogus user and system parameters to satisfy badly written PostScript
  264. % programs that incorrectly assume the existence of all the parameters
  265. % listed in Appendix C of the Red Book.  Note that some of these may become
  266. % real parameters later: code near the end of gs_init.ps takes care of
  267. % removing any such parameters from ps{user,system}params.
  268.  
  269. % psuserparams
  270.   /MaxFormItem 100000 .definepsuserparam
  271.   /MaxPatternItem 20000 .definepsuserparam
  272.   /MaxScreenItem 48000 .definepsuserparam
  273.   /MaxUPathItem 0 .definepsuserparam
  274.  
  275. % File Access Permission parameters
  276.   .currentglobal true .setglobal
  277.   /.checkFilePermitparams {
  278.     type /arraytype eq {
  279.       currentuserparams /LockFilePermissions get {
  280.         5 { pop } repeat /setuserparams /invalidaccess signalerror
  281.       }{
  282.         % in addition to validating the value, ensure the value is read/only
  283.         dup { readonly exch } forall
  284.         .currentglobal exch dup gcheck .setglobal length array exch .setglobal
  285.     astore readonly
  286.       }
  287.       ifelse
  288.     } {
  289.       5 { pop } repeat /setuserparams /typecheck signalerror
  290.     }
  291.     ifelse
  292.     true
  293.   } .bind def
  294. % Initialize the File Permission access control to wide open
  295. % These will only be accessed via current/set userparams.
  296. % Values are a string containing multiple nul terminated path strings
  297.   /PermitFileReading dup [ (*) ] .definepsuserparam
  298.     psuserparams exch /.checkFilePermitparams load put
  299.   /PermitFileWriting dup [ (*) ] .definepsuserparam
  300.     psuserparams exch /.checkFilePermitparams load put
  301.   /PermitFileControl dup [ (*) ] .definepsuserparam
  302.     psuserparams exch /.checkFilePermitparams load put
  303.   .setglobal
  304.  
  305. pssystemparams begin
  306.   /CurDisplayList 0 .forcedef
  307.   /CurFormCache 0 .forcedef
  308.   /CurInputDevice () .forcedef
  309.   /CurOutlineCache 0 .forcedef
  310.   /CurOutputDevice () .forcedef
  311.   /CurPatternCache 0 .forcedef
  312.   /CurUPathCache 0 .forcedef
  313.   /CurScreenStorage 0 .forcedef
  314.   /CurSourceList 0 .forcedef
  315.   /DoPrintErrors false .forcedef
  316.   /JobTimeout 0 .forcedef
  317.   /LicenseID (LN-001) .forcedef     % bogus
  318.   /MaxDisplayList 140000 .forcedef
  319.   /MaxFormCache 100000 .forcedef
  320.   /MaxImageBuffer 524288 .forcedef
  321.   /MaxOutlineCache 65000 .forcedef
  322.   /MaxPatternCache 100000 .forcedef
  323.   /MaxUPathCache 300000 .forcedef
  324.   /MaxScreenStorage 84000 .forcedef
  325.   /MaxSourceList 25000 .forcedef
  326.   /PrinterName product .forcedef
  327.   /RamSize 4194304 .forcedef
  328.   /WaitTimeout 40 .forcedef
  329. end
  330.  
  331. % Define the procedures for handling comment scanning.  The names
  332. % %ProcessComment and %ProcessDSCComment are known to the interpreter.
  333. % These procedures take the file and comment string and file as operands.
  334. /.checkprocesscomment {
  335.   dup null eq {
  336.     pop true
  337.   } {
  338.     dup xcheck {
  339.       type dup /arraytype eq exch /packedarraytype eq or
  340.     } {
  341.       pop false
  342.     } ifelse
  343.   } ifelse
  344. } .bind def
  345. /ProcessComment null .definepsuserparam
  346. psuserparams /ProcessComment {.checkprocesscomment} put
  347. (%ProcessComment) cvn {
  348.   /ProcessComment getuserparam
  349.   dup null eq { pop pop pop } { exec } ifelse
  350. } bind def
  351. /ProcessDSCComment null .definepsuserparam
  352. psuserparams /ProcessDSCComment {.checkprocesscomment} put
  353. /.loadingfont false def
  354. (%ProcessDSCComment) cvn {
  355.   /ProcessDSCComment getuserparam
  356.   dup null eq .loadingfont or { pop pop pop } { exec } ifelse
  357. } bind def
  358.  
  359. % ------ Miscellaneous ------ %
  360.  
  361. (<<) cvn            % - << -mark-
  362.   /mark load def
  363. % (>> is defined primitively.)
  364. /languagelevel 2 def
  365. % When running in Level 2 mode, this interpreter is supposed to be
  366. % compatible with Adobe version 2017.
  367. /version (2017) readonly def
  368.  
  369. % If binary tokens are supported by this interpreter,
  370. % set an appropriate default binary object format.
  371. /setobjectformat where
  372.  { pop
  373.    /RealFormat getsystemparam (IEEE) eq { 1 } { 3 } ifelse
  374.    /ByteOrder getsystemparam { 1 add } if
  375.    setobjectformat
  376.  } if
  377.  
  378. % Aldus Freehand versions 2.x check for the presence of the
  379. % setcolor operator, and if it is missing, substitute a procedure.
  380. % Unfortunately, the procedure takes different parameters from
  381. % the operator.  As a result, files produced by this application
  382. % cause an error if the setcolor operator is actually defined
  383. % and 'bind' is ever used.  Aldus fixed this bug in Freehand 3.0,
  384. % but there are a lot of files created by the older versions
  385. % still floating around.  Therefore, at Adobe's suggestion,
  386. % we implement the following dreadful hack in the 'where' operator:
  387. %      If the key is /setcolor, and
  388. %        there is a dictionary named FreeHandDict, and
  389. %        currentdict is that dictionary,
  390. %      then "where" consults only that dictionary and not any other
  391. %        dictionaries on the dictionary stack.
  392. .wheredict /setcolor {
  393.   /FreeHandDict .where {
  394.     /FreeHandDict get currentdict eq {
  395.       pop currentdict /setcolor known { currentdict true } { false } ifelse
  396.     } {
  397.       .where
  398.     } ifelse
  399.   } {
  400.     .where
  401.   } ifelse
  402. } bind put
  403.  
  404. % ------ Virtual memory ------ %
  405.  
  406. /currentglobal            % - currentglobal <bool>
  407.   /currentshared load def
  408. /gcheck                % <obj> gcheck <bool>
  409.   /scheck load def
  410. /setglobal            % <bool> setglobal -
  411.   /setshared load def
  412. % We can make the global dictionaries very small, because they auto-expand.
  413. /globaldict currentdict /shareddict .knownget not { 4 dict } if def
  414. /GlobalFontDirectory SharedFontDirectory def
  415.  
  416. % VMReclaim and VMThreshold are user parameters.
  417. /setvmthreshold {        % <int> setvmthreshold -
  418.   mark /VMThreshold 2 .argindex .dicttomark .setuserparams2 pop
  419. } odef
  420. /vmreclaim {            % <int> vmreclaim -
  421.   dup 0 gt {
  422.     .vmreclaim
  423.   } {
  424.     mark /VMReclaim 2 index .dicttomark .setuserparams2 pop
  425.   } ifelse
  426. } odef
  427. -1 setvmthreshold
  428.  
  429. % ------ IODevices ------ %
  430.  
  431. /.getdevparams where {
  432.   pop /currentdevparams {    % <iodevice> currentdevparams <dict>
  433.     .getdevparams .dicttomark
  434.   } odef
  435. } if
  436. /.putdevparams where {
  437.   pop /setdevparams {        % <iodevice> <dict> setdevparams -
  438.     dup type /dicttype ne { /setdevparams .systemvar /typecheck signalerror } if
  439.     mark 1 index { } forall counttomark 2 add index
  440.     .putdevparams pop pop
  441.   } odef
  442. } if
  443.  
  444. % ------ Job control ------ %
  445.  
  446. serverdict begin
  447.  
  448. % We could protect the job information better, but we aren't attempting
  449. % (currently) to protect ourselves against maliciousness.
  450.  
  451. /.jobsave //null def        % top-level save object
  452. /.jobsavelevel 0 def        % save depth of job (0 if .jobsave is null,
  453.                 % 1 otherwise)
  454. /.adminjob //true def        % status of current unencapsulated job
  455.  
  456. end        % serverdict
  457.  
  458. % Because there may be objects on the e-stack created since the job save,
  459. % we have to clear the e-stack before doing the end-of-job restore.
  460. % We do this by executing a 2 .stop, which is caught by the 2 .stopped
  461. % in .runexec; we leave on the o-stack a procedure to execute aftewards.
  462. %
  463. %**************** The definition of startjob is not complete yet, since
  464. % it doesn't reset stdin/stdout.
  465. /.startnewjob {            % <exit_bool> <password_level>
  466.                 %   .startnewjob -
  467.     serverdict /.jobsave get dup //null eq { pop } { restore } ifelse
  468.     exch {
  469.             % Unencapsulated job
  470.       serverdict /.jobsave //null put
  471.       serverdict /.jobsavelevel 0 put
  472.       serverdict /.adminjob 3 -1 roll 1 gt put
  473.     } {
  474.             % Encapsulated job
  475.       pop
  476.       serverdict /.jobsave save put
  477.       serverdict /.jobsavelevel 1 put
  478.       .userdict /quit { stop } .bind put  % CET 28-10 requires a procedure
  479.     } ifelse
  480.         % Reset the interpreter state.
  481.   clear cleardictstack
  482.   initgraphics
  483.   //false setglobal
  484.   2 vmreclaim    % Make sure GC'ed memory is reclaimed and freed.
  485. } bind def
  486. /.startjob {            % <exit_bool> <password> <finish_proc>
  487.                 %   .startjob <ok_bool>
  488.   vmstatus pop pop serverdict /.jobsavelevel get eq
  489.   2 .argindex .checkpassword 0 gt and {
  490.     exch .checkpassword exch count 3 roll count 3 sub { pop } repeat
  491.     cleardictstack
  492.         % Reset the e-stack back to the 2 .stopped in .runexec,
  493.         % passing the finish_proc to be executed afterwards.
  494.     2 .stop
  495.   } {        % Password check failed
  496.     pop pop pop //false
  497.   } ifelse
  498. } odef
  499. /startjob {            % <exit_bool> <password> startjob <ok_bool>
  500.     % This is a hack.  We really need some way to indicate explicitly
  501.     % to the interpreter that we are under control of a job server.
  502.   1 .argindex type /booleantype ne {
  503.     /startjob .systemvar /typecheck signalerror
  504.   } if
  505.   { .startnewjob //true } .startjob
  506. } odef
  507.  
  508. % The procedure to undo the job encapsulation 
  509. /.endjob {
  510.   clear cleardictstack
  511.   serverdict /.jobsave get dup //null eq { pop } { restore } ifelse
  512.   serverdict /.jobsave //null put
  513.   2 vmreclaim   % recover local and global VM
  514. } odef
  515.  
  516. systemdict begin
  517. /quit {                % - quit -
  518.   //systemdict begin serverdict /.jobsave get null eq
  519.    { end //quit }
  520.    { /quit .systemvar /invalidaccess /signalerror load end exec }
  521.   ifelse
  522. } bind odef
  523. end
  524.  
  525. % We would like to define exitserver as a procedure, using the code
  526. % that the Red Book says is equivalent to it.  However, since startjob
  527. % resets the exec stack, we can't do this, because control would never
  528. % proceed past the call on startjob if the exitserver is successful.
  529. % Instead, we need to construct exitserver out of pieces of startjob.
  530.  
  531. serverdict begin
  532.  
  533. /exitserver {            % <password> exitserver -
  534.   //true exch { .startnewjob } .startjob not {
  535.     /exitserver /invalidaccess signalerror
  536.   } if
  537. } bind def
  538.  
  539. end        % serverdict
  540.  
  541. % ------ Compatibility ------ %
  542.  
  543. % In Level 2 mode, the following replace the definitions that gs_statd.ps
  544. % installs in statusdict and serverdict.
  545. % Note that statusdict must be allocated in local VM.
  546. % We don't bother with many of these yet.
  547.  
  548. /.dict1 { exch mark 3 1 roll .dicttomark } bind def
  549.  
  550. currentglobal false setglobal 25 dict exch setglobal begin
  551. currentsystemparams
  552.  
  553. % The following do not depend on the presence of setpagedevice.
  554. /buildtime 1 index /BuildTime get def
  555. % Also define /buildtime in systemdict because Adobe does so and some fonts use it as ID
  556. systemdict /buildtime dup load put
  557. /byteorder 1 index /ByteOrder get def
  558. /checkpassword { .checkpassword 0 gt } bind def
  559. dup /DoStartPage known
  560.  { /dostartpage { /DoStartPage getsystemparam } bind def
  561.    /setdostartpage { /DoStartPage .dict1 setsystemparams } bind def
  562.  } if
  563. dup /StartupMode known
  564.  { /dosysstart { /StartupMode getsystemparam 0 ne } bind def
  565.    /setdosysstart { { 1 } { 0 } ifelse /StartupMode .dict1 setsystemparams } bind def
  566.  } if
  567. %****** Setting jobname is supposed to set userparams.JobName, too.
  568. /jobname { /JobName getuserparam } bind def
  569. /jobtimeout { /JobTimeout getuserparam } bind def
  570. /ramsize { /RamSize getsystemparam } bind def
  571. /realformat 1 index /RealFormat get def
  572. dup /PrinterName known
  573.  { /setprintername { /PrinterName .dict1 setsystemparams } bind def
  574.  } if
  575. /printername
  576.  { currentsystemparams /PrinterName .knownget not { () } if exch copy
  577.  } bind def
  578. currentuserparams /WaitTimeout known
  579.  { /waittimeout { /WaitTimeout getuserparam } bind def
  580.  } if
  581.  
  582. % The following do require setpagedevice.
  583. /.setpagedevice where { pop } { (%END PAGEDEVICE) .skipeof } ifelse
  584. /defaulttimeouts
  585.  { currentsystemparams dup
  586.    /JobTimeout .knownget not { 0 } if
  587.    exch /WaitTimeout .knownget not { 0 } if
  588.    currentpagedevice /ManualFeedTimeout .knownget not { 0 } if
  589.  } bind def
  590. /margins
  591.  { currentpagedevice /Margins .knownget { exch } { [0 0] } ifelse
  592.  } bind def
  593. /pagemargin
  594.  { currentpagedevice /PageOffset .knownget { 0 get } { 0 } ifelse
  595.  } bind def
  596. /pageparams
  597.  { currentpagedevice
  598.    dup /Orientation .knownget { 1 and ORIENT1 { 1 xor } if } { 0 } ifelse exch
  599.    dup /PageSize get aload pop 3 index 0 ne { exch } if 3 2 roll
  600.    /PageOffset .knownget { 0 get } { 0 } ifelse 4 -1 roll
  601.  } bind def
  602. /setdefaulttimeouts
  603.  { exch mark /ManualFeedTimeout 3 -1 roll
  604.    /Policies mark /ManualFeedTimeout 1 .dicttomark
  605.    .dicttomark setpagedevice
  606.    /WaitTimeout exch mark /JobTimeout 5 2 roll .dicttomark setsystemparams
  607.  } bind def
  608. /.setpagesize { 2 array astore /PageSize .dict1 setpagedevice } bind def
  609. /setduplexmode { /Duplex .dict1 setpagedevice } bind def
  610. /setmargins
  611.  { exch 2 array astore /Margins .dict1 setpagedevice
  612.  } bind def
  613. /setpagemargin { 0 2 array astore /PageOffset .dict1 setpagedevice } bind def
  614. /setpageparams
  615.  { mark /PageSize 6 -2 roll
  616.    4 index 1 and ORIENT1 { 1 } { 0 } ifelse ne { exch } if 2 array astore
  617.    /Orientation 5 -1 roll ORIENT1 { 1 xor } if
  618.    /PageOffset counttomark 2 add -1 roll 0 2 array astore
  619.    .dicttomark setpagedevice
  620.  } bind def
  621. /setresolution
  622.  { dup 2 array astore /HWResolution .dict1 setpagedevice
  623.  } bind def
  624. %END PAGEDEVICE
  625.  
  626. % The following are not implemented yet.
  627. %manualfeed
  628. %manualfeedtimeout
  629. %pagecount
  630. %pagestackorder
  631. %setpagestackorder
  632.  
  633. pop        % currentsystemparams
  634.  
  635. % Flag the current dictionary so it will be swapped when we
  636. % change language levels.  (See zmisc2.c for more information.)
  637. /statusdict currentdict def
  638.  
  639. currentdict end
  640. /statusdict exch .forcedef    % statusdict is local, systemdict is global
  641.  
  642. % The following compatibility operators are in systemdict.  They are
  643. % defined here, rather than in gs_init.ps, because they require the
  644. % resource machinery.
  645.  
  646. /devforall {        % <proc> <scratch> devforall -
  647.   exch {
  648.     1 index currentdevparams
  649.     /Type .knownget { /FileSystem eq } { false } ifelse
  650.     { exec } { pop pop } ifelse
  651.   } /exec load 3 packedarray cvx exch
  652.   (*) 3 1 roll /IODevice resourceforall
  653. } odef
  654. /devstatus {        % <(%disk*%)> devstatus <searchable> <writable>
  655.             %   <hasNames> <mounted> <removable> <searchOrder>
  656.             %   <freePages> <size> true
  657.             % <string> devstatus false
  658.   dup length 5 ge {
  659.     dup 0 5 getinterval (%disk) eq {
  660.       dup /IODevice resourcestatus {
  661.     pop pop dup currentdevparams
  662.     dup /Searchable get
  663.     exch dup /Writeable get
  664.     exch dup /HasNames get
  665.     exch dup /Mounted get
  666.     exch dup /Removable get
  667.     exch dup /SearchOrder get
  668.     exch dup /Free get
  669.     exch /LogicalSize get
  670.     9 -1 roll pop true
  671.       } {
  672.     pop false
  673.       } ifelse
  674.     } {
  675.       pop false
  676.     } ifelse
  677.   } {
  678.     pop false
  679.   } ifelse
  680. } odef
  681.  
  682. % ------ Color spaces ------ %
  683. % gs_res.ps uses these entries in colorspacedict
  684. % to populate the ColorSpaceFamily resource, so we need
  685. % to add the supported spaces.
  686. %
  687. systemdict /colorspacedict get begin
  688. /CIEBasedA [] def
  689. /CIEBasedABC [] def
  690. /DevicePixel [] def
  691. /Indexed [] def
  692. /Pattern [] def
  693. /Separation [] def
  694. end
  695.  
  696.  
  697.  
  698. % ------ CIE color rendering ------ %
  699.  
  700. % Define findcolorrendering and a default ColorRendering ProcSet.
  701.  
  702. /findcolorrendering {        % <intentname> findcolorrendering
  703.                 %   <crdname> <found>
  704.     % Adobe interpreters report /findcolorrendering (literal name), not the
  705.     % operator itself, if an error occurs in findcolorrendering.
  706.     /findcolorrendering {
  707.     /ColorRendering /ProcSet findresource
  708.     1 .argindex dup type /nametype eq { .namestring } if (.) concatstrings
  709.     1 index /GetPageDeviceName get exec dup type /nametype eq { .namestring } if (.) concatstrings
  710.     2 index /GetHalftoneName get exec dup type /nametype eq { .namestring } if
  711.     concatstrings concatstrings cvn    % stack: intentname procset crdname
  712.     dup /ColorRendering resourcestatus {
  713.         pop pop exch pop exch pop true
  714.     } {
  715.         pop /GetSubstituteCRD get exec false
  716.     } ifelse
  717.     } .errorexec
  718. } odef
  719.  
  720. 5 dict dup begin
  721.  
  722. /GetPageDeviceName {        % - GetPageDeviceName <name>
  723.   currentpagedevice dup /PageDeviceName .knownget {
  724.     exch pop dup null eq { pop /none } if
  725.   } {
  726.     pop /none
  727.   } ifelse
  728. } bind def
  729.  
  730. /GetHalftoneName {        % - GetHalftoneName <name>
  731.   currenthalftone /HalftoneName .knownget not { /none } if
  732. } bind def
  733.  
  734. /GetSubstituteCRD {        % <intentname> GetSubstituteCRD <crdname>
  735.   pop /DefaultColorRendering
  736. } bind def
  737.  
  738. end
  739. % The resource machinery hasn't been activated, so just save the ProcSet
  740. % and let .fixresources finish the installation process.
  741. /ColorRendering exch def
  742.  
  743. % Define setcolorrendering.
  744.  
  745. /.colorrenderingtypes 5 dict def
  746.  
  747. /setcolorrendering {        % <crd> setcolorrendering -
  748.   dup /ColorRenderingType get
  749.   dup type /integertype ne {
  750.     /setcolorrendering .systemvar /typecheck signalerror
  751.   } if
  752.   //.colorrenderingtypes exch .knownget {
  753.      exec 
  754.   } {
  755.     /setcolorrendering .systemvar /rangecheck signalerror
  756.   } ifelse
  757. } odef
  758.  
  759. /.setcolorrendering1 where { pop } { (%END CRD) .skipeof } ifelse
  760.  
  761. .colorrenderingtypes 1 {
  762.   % Adobe ProcSet "Adobe_AGM_Core 2.0 0" places an /Intent key into CRD's 
  763.   dup /Intent .knownget {
  764.     //.renderingintentdict exch .knownget { .setrenderingintent } if
  765.   } if
  766.   dup .buildcolorrendering1 .setcolorrendering1
  767. } .bind put
  768.  
  769. % Note: the value 101 in the next line must be the same as the value of
  770. % GX_DEVICE_CRD1_TYPE in gscrdp.h.
  771. .colorrenderingtypes 101 {
  772.   dup .builddevicecolorrendering1 .setdevicecolorrendering1
  773. } .bind put
  774.  
  775. % sRGB output CRD, D65 white point
  776. mark
  777. /ColorRenderingType 1
  778. /RangePQR [ -0.5 2 -0.5 2 -0.5 2 ] readonly
  779.  
  780. % Bradford Cone Space
  781. /MatrixPQR [ 0.8951 -0.7502  0.0389
  782.          0.2664  1.7135 -0.0685
  783.         -0.1614  0.0367  1.0296] readonly
  784.  
  785. /MatrixLMN [ 3.240449 -0.969265  0.055643
  786.         -1.537136  1.876011 -0.204026
  787.         -0.498531  0.041556  1.057229 ] readonly
  788.  
  789. % Inverse sRGB gamma transform
  790. /EncodeABC [ { dup 0.00304 le
  791.                 { 12.92321 mul }
  792.                 { 1 2.4 div exp 1.055 mul 0.055 sub }
  793.                ifelse
  794.              } bind dup dup
  795.            ] readonly
  796.  
  797. /WhitePoint [ 0.9505 1 1.0890 ] readonly % D65
  798. /BlackPoint [ 0 0 0 ] readonly
  799.  
  800. % VonKries-like transform in Bradford Cone Space
  801.    /TransformPQR
  802.      % The implementations have been moved to C for performance.
  803.      [ { .TransformPQR_scale_WB0 } bind
  804.        { .TransformPQR_scale_WB1 } bind 
  805.        { .TransformPQR_scale_WB2 } bind
  806.      ] readonly
  807. .dicttomark setcolorrendering
  808.  
  809. %END CRD
  810.  
  811. % Initialize a CIEBased color space for sRGB.
  812. /CIEsRGB [ /CIEBasedABC
  813.   mark
  814.     /DecodeLMN [ {
  815.       dup 0.03928 le { 12.92321 div } { 0.055 add 1.055 div 2.4 exp } ifelse
  816.     } bind dup dup ] readonly
  817.     /MatrixLMN [
  818.       0.412457 0.212673 0.019334
  819.       0.357576 0.715152 0.119192
  820.       0.180437 0.072175 0.950301
  821.     ] readonly
  822.     /WhitePoint [0.9505 1.0 1.0890] readonly
  823.   .dicttomark readonly
  824. ] readonly def
  825.  
  826. % ------ Painting ------ %
  827.  
  828. % A straightforward definition of execform that doesn't actually
  829. % do any caching.
  830. /.execform1 {
  831.     % This is a separate operator so that the stacks will be restored
  832.     % properly if an error occurs.
  833.   dup /Matrix get concat
  834.   dup /BBox get aload pop
  835.   exch 3 index sub exch 2 index sub rectclip
  836.   dup /PaintProc get
  837.   1 index /Implementation known not {
  838.     1 index dup /Implementation null .forceput readonly pop
  839.   } if
  840.   exec
  841. } .bind odef    % must bind .forceput
  842.  
  843. /.formtypes 5 dict
  844.   dup 1 /.execform1 load put
  845. def
  846.  
  847. /execform {            % <form> execform -
  848.   gsave {
  849.     dup /FormType get //.formtypes exch get exec
  850.   } stopped grestore { stop } if
  851. } odef
  852.  
  853. /.patterntypes 5 dict
  854.   dup 1 /.buildpattern1 load put
  855. def
  856.  
  857. /makepattern {            % <proto_dict> <matrix> makepattern <pattern>
  858.   dup type /dicttype eq {
  859.      % "<dict> makepattern" reports /typecheck on Adobe
  860.      /makepattern .systemvar /typecheck signalerror
  861.   } if
  862.   //.patterntypes 2 .argindex /PatternType get .knownget not {
  863.       /makepattern .systemvar /rangecheck signalerror
  864.   } if
  865.   .currentglobal false .setglobal exch
  866.         % Stack: proto matrix global buildproc
  867.   3 index dup length 1 add dict .copydict
  868.         % Stack: proto matrix global buildproc newdict
  869.   3 index 3 -1 roll exec
  870.         % Stack: proto matrix global newdict instance
  871.   % Create an 'Implementation' entry for the pattern dict.  The PRLM 3rd says
  872.   % this about the contents of Implementation:  "The type and value of this
  873.   % entry are implementation-dependent."  The CET (page 2 of 18-02f) expects
  874.   % that this entry be an array and that the second element of the array be a
  875.   % gstate. We put our pattern instance struct into the first element of the
  876.   % array.
  877.   1 index /Implementation 3 -1 roll
  878.   .getCPSImode { gstate } { //null } ifelse 2 array astore
  879.   put                % put Implementation into the pattern dict.
  880.         % Stack: proto matrix global newdict
  881.   readonly exch .setglobal exch pop exch pop
  882. } odef
  883.  
  884. /setpattern {            % [<comp1> ...] <pattern> setpattern -
  885.   { currentcolorspace 0 get /Pattern ne {
  886.       [ /Pattern currentcolorspace ] setcolorspace
  887.     } if setcolor
  888.   } stopped {
  889.     /setpattern .systemvar $error /errorname get signalerror
  890.   } if
  891. } odef
  892.  
  893. % The following functions emulate the actions of findcmykcustomcolor and
  894. % setcustomcolor.  These functions are described in Adobe's TN 5044.  That
  895. % same document also says "The following ìoperatorsî are not defined in the
  896. % PostScript Language Reference Manual, but should be used as pseudo-operators
  897. % in your PostScript language output. Separation applications from Adobe
  898. % Systems and other vendors will redefine these convention operators to
  899. % separate your documents.  Your application should conditionally define
  900. % procedures with these special names, as shown later in this document."
  901. %
  902. % We are providing these functions because we have found files created by
  903. % "QuarkXPress: pictwpstops filter 1.0" which produce bad shading dictionaries
  904. % if these operators are not defined. 
  905.  
  906. % Conditionally disable the TN 5044 psuedo-ops if NO_TN5044 specified
  907. /NO_TN5044 where { pop (%END TN 5044 psuedo-ops) .skipeof } if
  908.  
  909. % TN 5044 does not define the contents of the array.  We are simply putting
  910. % the values given into an array.  This is consistent with what we see when
  911. % testing with Adobe Distiller 6.0.
  912. %   <cyan> <magenta> <yellow> <black> <key> findcmykcustomcolor <array>
  913. /findcmykcustomcolor { 5 array astore } bind def
  914.  
  915. % Build a tint transform function for use by setcustomcolor.  This function
  916. % is for a Separation color space which has a DeviceCMYK base color space
  917. % (i.e. 1 input and 4 outputs).  The input to buildcustomtinttransform is the
  918. % array created by findcmykcustomcolor.  The resulting function is:
  919. %   { dup cyan mul exch dup magenta mul exch dup yellow mul exch black mul }
  920. %   Where cyan, magenta, yellow, and black are values from the array.
  921. /buildcustomtinttransform    % <array> buildcustomtinttransform <function>
  922. { [ /dup load 2 index 0 get /mul load
  923.   /exch load /dup load 6 index 1 get /mul load
  924.   /exch load /dup load 10 index 2 get /mul load
  925.   /exch load 13 index 3 get /mul load
  926.   ] cvx bind
  927.   exch pop            % Remove the input array
  928. } bind def
  929.  
  930. % Set a custom color based upon a tint and array which describes the custom
  931. % color.  See findcmykcustomcolor.  First we create and then set a Separation
  932. % colorspace.  Then we set the specified color.
  933. % Note that older Adobe ProcSets apparently allow for 'null' as the tint
  934. % for some reason, so an alternate operational mode is tolerated:
  935. %                         null setcustomcolor -
  936. /setcustomcolor            % <array> <tint> setcustomcolor -
  937. { dup //null ne {
  938.     % Start building Separation colorspace
  939.     [ /Separation 3 index 4 get    % Get separation name from array's key
  940.     /DeviceCMYK
  941.     5 index //buildcustomtinttransform exec] % build the tint transform function
  942.     setcolorspace            % Set the Separation color space as current
  943.     setcolor            % Set the tint as the current color
  944.     pop                % Remove the input array
  945.   }
  946.   { pop }    % 'null' as the tint is ignored
  947.   ifelse
  948. } bind def
  949.  
  950. % This proc is supposed to implement a version of overprinting. TN 5044 says
  951. % that this proc is not used by any shipping host-based application. We have
  952. % only found it being used in a proc set in files by Canvas from Deneba Systems.
  953. % Even their proc set does not actually do any overprinting.  However their
  954. % files crash if this is not defined.  Thus we have a copy of this proc but
  955. % we are simply checking for inputs being -1 and if so then we set the value
  956. % to 0.
  957. /setcmykoverprint {
  958.   4 { dup -1 eq { pop 0 } if 4 1 roll } repeat setcmykcolor
  959. } bind def
  960.  
  961. /separation_all [/Separation /All /DeviceCMYK { dup dup dup } bind ] readonly def
  962.  
  963. % Collect the arguments into the image dictionary
  964. % <width> <height> <bits/sample> <matrix> <proc> args2dict <dict>
  965. /args2dict {
  966.   10 dict begin
  967.   {1 0} 1
  968.   { /ImageType /Decode /DataSource /ImageMatrix /BitsPerComponent /Height /Width
  969.   } { exch def } forall
  970.   currentdict end
  971. } bind def
  972.  
  973. % Prints (1-gray) on all separations.
  974. % <gray> setseparationgray -
  975. /setseparationgray {
  976.   //separation_all setcolorspace
  977.   1 exch sub setcolor
  978. } bind def
  979.  
  980. % Renders an image whose sample values specify the amount of the custom color.
  981. % <width> <height> <bits/sample> <matrix> <proc> <array> customcolorimage -
  982. /customcolorimage {
  983.   gsave
  984.   [ /Separation 2 index 4 get /DeviceCMYK 5 -1 roll //buildcustomtinttransform exec] setcolorspace
  985.   //args2dict exec image
  986.   grestore
  987. } bind def
  988.  
  989. % Renders an image on all process and custom color plates.
  990. % <width> <height> <bits/sample> <matrix> <proc>
  991. /separationimage {
  992.   gsave
  993.   //separation_all setcolorspace
  994.   //args2dict exec image
  995.   grestore
  996. } bind def
  997.  
  998. { /buildcustomtinttransform /separation_all /args2dict }
  999. { currentdict exch undef } forall
  1000.  
  1001. %END TN 5044 psuedo-ops
  1002.  
  1003. end                % level2dict
  1004.